/* eslint-disable */
import {
  DataTextureLoader,
  DataUtils,
  FloatType,
  HalfFloatType,
  LinearEncoding,
  LinearFilter,
  NearestFilter,
  RGBEEncoding,
  RGBEFormat,
  RGBFormat,
  UnsignedByteType
} from './three.module.js';

// https://github.com/mrdoob/three.js/issues/5552
// http://en.wikipedia.org/wiki/RGBE_image_format

var RGBELoader = function(manager) {

  DataTextureLoader.call(this, manager);

  this.type = UnsignedByteType;

};

RGBELoader.prototype = Object.assign(Object.create(DataTextureLoader.prototype), {

  constructor: RGBELoader,

  // adapted from http://www.graphics.cornell.edu/~bjw/rgbe.html

  parse: function(buffer) {

    var
      /* return codes for rgbe routines */
      // RGBE_RETURN_SUCCESS = 0,
      RGBE_RETURN_FAILURE = -1;

    /* default error routine.  change this to change error handling */
    var rgbe_read_error = 1;
    var rgbe_write_error = 2;
    var rgbe_format_error = 3;
    var rgbe_memory_error = 4;
    var rgbe_error = function(rgbe_error_code, msg) {

      switch (rgbe_error_code) {

        case rgbe_read_error: console.error('THREE.RGBELoader Read Error: ' + (msg || ''));
          break;
        case rgbe_write_error: console.error('THREE.RGBELoader Write Error: ' + (msg || ''));
          break;
        case rgbe_format_error: console.error('THREE.RGBELoader Bad File Format: ' + (msg || ''));
          break;
        default:
        case rgbe_memory_error: console.error('THREE.RGBELoader: Error: ' + (msg || ''));

      }

      return RGBE_RETURN_FAILURE;

    };

    /* offsets to red, green, and blue components in a data (float) pixel */
    // RGBE_DATA_RED = 0,
    // RGBE_DATA_GREEN = 1,
    // RGBE_DATA_BLUE = 2,

    /* number of floats per pixel, use 4 since stored in rgba image format */
    // RGBE_DATA_SIZE = 4,

    /* flags indicating which fields in an rgbe_header_info are valid */
    var RGBE_VALID_PROGRAMTYPE = 1;
    var RGBE_VALID_FORMAT = 2;
    var RGBE_VALID_DIMENSIONS = 4;

    var NEWLINE = '\n';

    var fgets = function(buffer, lineLimit, consume) {

      lineLimit = !lineLimit ? 1024 : lineLimit;
      var p = buffer.pos;
      var i = -1; var len = 0; var s = ''; var chunkSize = 128;
      var chunk = String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)))
				;
      while (((i = chunk.indexOf(NEWLINE)) < 0) && (len < lineLimit) && (p < buffer.byteLength)) {

        s += chunk; len += chunk.length;
        p += chunkSize;
        chunk += String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)));

      }

      if (i > -1) {

        /* for (i=l-1; i>=0; i--) {
						byteCode = m.charCodeAt(i);
						if (byteCode > 0x7f && byteCode <= 0x7ff) byteLen++;
						else if (byteCode > 0x7ff && byteCode <= 0xffff) byteLen += 2;
						if (byteCode >= 0xDC00 && byteCode <= 0xDFFF) i--; //trail surrogate
					}*/
        if (consume !== false) buffer.pos += len + i + 1;
        return s + chunk.slice(0, i);

      }

      return false;

    };

    /* minimal header reading.  modify if you want to parse more information */
    var RGBE_ReadHeader = function(buffer) {

      var line; var match;

      // regexes to parse header info fields
      var magic_token_re = /^#\?(\S+)/;
      var gamma_re = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/;
      var exposure_re = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/;
      var format_re = /^\s*FORMAT=(\S+)\s*$/;
      var dimensions_re = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/;

      // RGBE format header struct
      var header = {

        valid: 0, /* indicate which fields are valid */

        string: '', /* the actual header string */

        comments: '', /* comments found in header */

        programtype: 'RGBE', /* listed at beginning of file to identify it after "#?". defaults to "RGBE" */

        format: '', /* RGBE format, default 32-bit_rle_rgbe */

        gamma: 1.0, /* image has already been gamma corrected with given gamma. defaults to 1.0 (no correction) */

        exposure: 1.0, /* a value of 1.0 in an image corresponds to <exposure> watts/steradian/m^2. defaults to 1.0 */

        width: 0, height: 0 /* image dimensions, width/height */

      };

      if (buffer.pos >= buffer.byteLength || !(line = fgets(buffer))) {

        return rgbe_error(rgbe_read_error, 'no header found');

      }

      /* if you want to require the magic token then uncomment the next line */
      if (!(match = line.match(magic_token_re))) {

        return rgbe_error(rgbe_format_error, 'bad initial token');

      }

      header.valid |= RGBE_VALID_PROGRAMTYPE;
      header.programtype = match[ 1 ];
      header.string += line + '\n';

      while (true) {

        line = fgets(buffer);
        if (line === false) break;
        header.string += line + '\n';

        if (line.charAt(0) === '#') {

          header.comments += line + '\n';
          continue; // comment line

        }

        if (match = line.match(gamma_re)) {

          header.gamma = parseFloat(match[ 1 ], 10);

        }

        if (match = line.match(exposure_re)) {

          header.exposure = parseFloat(match[ 1 ], 10);

        }

        if (match = line.match(format_re)) {

          header.valid |= RGBE_VALID_FORMAT;
          header.format = match[ 1 ];// '32-bit_rle_rgbe';

        }

        if (match = line.match(dimensions_re)) {

          header.valid |= RGBE_VALID_DIMENSIONS;
          header.height = parseInt(match[ 1 ], 10);
          header.width = parseInt(match[ 2 ], 10);

        }

        if ((header.valid & RGBE_VALID_FORMAT) && (header.valid & RGBE_VALID_DIMENSIONS)) break;

      }

      if (!(header.valid & RGBE_VALID_FORMAT)) {

        return rgbe_error(rgbe_format_error, 'missing format specifier');

      }

      if (!(header.valid & RGBE_VALID_DIMENSIONS)) {

        return rgbe_error(rgbe_format_error, 'missing image size specifier');

      }

      return header;

    };

    var RGBE_ReadPixels_RLE = function(buffer, w, h) {

      var data_rgba; var offset; var pos; var count; var byteValue;
      var scanline_buffer; var ptr; var ptr_end; var i; var l; var off; var isEncodedRun;
      var scanline_width = w; var num_scanlines = h; var rgbeStart
				;

      if (
        // run length encoding is not allowed so read flat
        ((scanline_width < 8) || (scanline_width > 0x7fff)) ||
					// this file is not run length encoded
					((buffer[ 0 ] !== 2) || (buffer[ 1 ] !== 2) || (buffer[ 2 ] & 0x80))
      ) {

        // return the flat buffer
        return new Uint8Array(buffer);

      }

      if (scanline_width !== ((buffer[ 2 ] << 8) | buffer[ 3 ])) {

        return rgbe_error(rgbe_format_error, 'wrong scanline width');

      }

      data_rgba = new Uint8Array(4 * w * h);

      if (!data_rgba.length) {

        return rgbe_error(rgbe_memory_error, 'unable to allocate buffer space');

      }

      offset = 0; pos = 0; ptr_end = 4 * scanline_width;
      rgbeStart = new Uint8Array(4);
      scanline_buffer = new Uint8Array(ptr_end);

      // read in each successive scanline
      while ((num_scanlines > 0) && (pos < buffer.byteLength)) {

        if (pos + 4 > buffer.byteLength) {

          return rgbe_error(rgbe_read_error);

        }

        rgbeStart[ 0 ] = buffer[ pos++ ];
        rgbeStart[ 1 ] = buffer[ pos++ ];
        rgbeStart[ 2 ] = buffer[ pos++ ];
        rgbeStart[ 3 ] = buffer[ pos++ ];

        if ((rgbeStart[ 0 ] != 2) || (rgbeStart[ 1 ] != 2) || (((rgbeStart[ 2 ] << 8) | rgbeStart[ 3 ]) != scanline_width)) {

          return rgbe_error(rgbe_format_error, 'bad rgbe scanline format');

        }

        // read each of the four channels for the scanline into the buffer
        // first red, then green, then blue, then exponent
        ptr = 0;
        while ((ptr < ptr_end) && (pos < buffer.byteLength)) {

          count = buffer[ pos++ ];
          isEncodedRun = count > 128;
          if (isEncodedRun) count -= 128;

          if ((count === 0) || (ptr + count > ptr_end)) {

            return rgbe_error(rgbe_format_error, 'bad scanline data');

          }

          if (isEncodedRun) {

            // a (encoded) run of the same value
            byteValue = buffer[ pos++ ];
            for (i = 0; i < count; i++) {

              scanline_buffer[ ptr++ ] = byteValue;

            }
            // ptr += count;

          } else {

            // a literal-run
            scanline_buffer.set(buffer.subarray(pos, pos + count), ptr);
            ptr += count; pos += count;

          }

        }

        // now convert data from buffer into rgba
        // first red, then green, then blue, then exponent (alpha)
        l = scanline_width; // scanline_buffer.byteLength;
        for (i = 0; i < l; i++) {

          off = 0;
          data_rgba[ offset ] = scanline_buffer[ i + off ];
          off += scanline_width; // 1;
          data_rgba[ offset + 1 ] = scanline_buffer[ i + off ];
          off += scanline_width; // 1;
          data_rgba[ offset + 2 ] = scanline_buffer[ i + off ];
          off += scanline_width; // 1;
          data_rgba[ offset + 3 ] = scanline_buffer[ i + off ];
          offset += 4;

        }

        num_scanlines--;

      }

      return data_rgba;

    };

    var RGBEByteToRGBFloat = function(sourceArray, sourceOffset, destArray, destOffset) {

      var e = sourceArray[ sourceOffset + 3 ];
      var scale = Math.pow(2.0, e - 128.0) / 255.0;

      destArray[ destOffset + 0 ] = sourceArray[ sourceOffset + 0 ] * scale;
      destArray[ destOffset + 1 ] = sourceArray[ sourceOffset + 1 ] * scale;
      destArray[ destOffset + 2 ] = sourceArray[ sourceOffset + 2 ] * scale;

    };

    var RGBEByteToRGBHalf = function(sourceArray, sourceOffset, destArray, destOffset) {

      var e = sourceArray[ sourceOffset + 3 ];
      var scale = Math.pow(2.0, e - 128.0) / 255.0;

      destArray[ destOffset + 0 ] = DataUtils.toHalfFloat(sourceArray[ sourceOffset + 0 ] * scale);
      destArray[ destOffset + 1 ] = DataUtils.toHalfFloat(sourceArray[ sourceOffset + 1 ] * scale);
      destArray[ destOffset + 2 ] = DataUtils.toHalfFloat(sourceArray[ sourceOffset + 2 ] * scale);

    };

    var byteArray = new Uint8Array(buffer);
    byteArray.pos = 0;
    var rgbe_header_info = RGBE_ReadHeader(byteArray);

    if (RGBE_RETURN_FAILURE !== rgbe_header_info) {

      var w = rgbe_header_info.width;
      var h = rgbe_header_info.height;
      var image_rgba_data = RGBE_ReadPixels_RLE(byteArray.subarray(byteArray.pos), w, h);

      if (RGBE_RETURN_FAILURE !== image_rgba_data) {

        switch (this.type) {

          case UnsignedByteType:

            var data = image_rgba_data;
            var format = RGBEFormat; // handled as THREE.RGBAFormat in shaders
            var type = UnsignedByteType;
            break;

          case FloatType:

            var numElements = (image_rgba_data.length / 4) * 3;
            var floatArray = new Float32Array(numElements);

            for (var j = 0; j < numElements; j++) {

              RGBEByteToRGBFloat(image_rgba_data, j * 4, floatArray, j * 3);

            }

            var data = floatArray;
            var format = RGBFormat;
            var type = FloatType;
            break;

          case HalfFloatType:

            var numElements = (image_rgba_data.length / 4) * 3;
            var halfArray = new Uint16Array(numElements);

            for (var j = 0; j < numElements; j++) {

              RGBEByteToRGBHalf(image_rgba_data, j * 4, halfArray, j * 3);

            }

            var data = halfArray;
            var format = RGBFormat;
            var type = HalfFloatType;
            break;

          default:

            console.error('THREE.RGBELoader: unsupported type: ', this.type);
            break;

        }

        return {
          width: w, height: h,
          data: data,
          header: rgbe_header_info.string,
          gamma: rgbe_header_info.gamma,
          exposure: rgbe_header_info.exposure,
          format: format,
          type: type
        };

      }

    }

    return null;

  },

  setDataType: function(value) {

    this.type = value;
    return this;

  },

  load: function(url, onLoad, onProgress, onError) {

    function onLoadCallback(texture, texData) {

      switch (texture.type) {

        case UnsignedByteType:

          texture.encoding = RGBEEncoding;
          texture.minFilter = NearestFilter;
          texture.magFilter = NearestFilter;
          texture.generateMipmaps = false;
          texture.flipY = true;
          break;

        case FloatType:

          texture.encoding = LinearEncoding;
          texture.minFilter = LinearFilter;
          texture.magFilter = LinearFilter;
          texture.generateMipmaps = false;
          texture.flipY = true;
          break;

        case HalfFloatType:

          texture.encoding = LinearEncoding;
          texture.minFilter = LinearFilter;
          texture.magFilter = LinearFilter;
          texture.generateMipmaps = false;
          texture.flipY = true;
          break;

      }

      if (onLoad) onLoad(texture, texData);

    }

    return DataTextureLoader.prototype.load.call(this, url, onLoadCallback, onProgress, onError);

  }

});

export { RGBELoader };
